Telecommunications network management method and system

ABSTRACT

The invention relates to a management method and a management system for managing a telecommunications network. The system comprises a database including information about the managed network, said information being in the form of objects that relate to the network elements to be managed and in the form of references between the different objects, said references indicating the dependencies between the objects. To provide a rapidly operating system in which arbitrary circular dependencies between the objects can easily be coped with to decide when an object can be unlocked to allow any part of the system to change said object, an auxiliary data structure that has no cyclic dependencies between its objects is added to the system and this auxiliary data structure is utilized to decide when an object can be unlocked.

The present invention relates to a management method according to thepreamble of the attached claim 1 for managing a telecommunicationsnetwork, and to a telecommunications network management system accordingto the preamble of the attached claim 6. The telecommunications networkto be managed may be e.g. a SDH (Synchronous Digital Hierarchy) network,a PDH (Plesiochronous Digital Hierarchy) network, or a combination ofsuch networks.

The basic situation in network management is usually such that anoperator managing a telecommunication networks, e.g. a telephonecompany, has a plurality of customers (i.e. network users) in additionto the physical network. The operator sells the customers variousservices that utilize the network. (A public network will be used hereinas an example; in principle, however, the same description applies to aprivate operator managing e.g. an organization network). To meetcustomers' data transmission requirements in the physical network, theoperator utilizes a number of facilities or operative processes for theprovision of customer services. These operative processes can be dividedinto groups in accordance with the functions for which they areintended:

Service Provisioning taking care of the performance of customerservices, including e.g. invoicing customers for services.

Operation & Maintenance for keeping the network operative to allow theusage of customer services. One of the most important functions in thisrespect is the supervision and repair of network faults.

Planning & Development, the function of which is to develop networkoperation so as to better meet customers'needs and to increase theoverall profitability of the operator enterprise.

As appears from the above, network management takes place on severaldifferent levels, depending on the extent to which the functions to beperformed on a specific level are associated with the overall managementof the operator enterprise. The management of a telecommunicationsnetwork is generally divided into four different levels, which are frombottom to top as follows:

network element management layer,

network management layer,

service management layer, and

business management layer.

This division is used e.g. in the ITU-T (the former CCITT)recommendation M.3010, which specifies a kind of framework for themanagement architecture of a telecommunications network. The bottomlayer below the above four layers is the equipment itself; theseequipments are managed by installation and field engineering tools.

The network element management layer means the management of anindividual network element (such as a multiplexer or a cross-connectiondevice) as a separate component without simultaneously paying attentionto the condition of the network or other network elements. The majorityof so called “network management” systems commercially available todayare actually network element management systems within this layer.

The network management layer is concerned with the management of theentire telecommunications network, such as overall management of networkconnections. One example is the creation of connections and theend-to-end supervision of their condition. This means that e.g. alarmsdetected on equipment are not just displayed against that equipment, butthey are also propagated to show what services (paths and circuits) areaffected by the fault, if any. The present invention is positioned inthis layer.

As distinct from the above, the service management layer is notconcerned with technical network management. It takes care of e.g.customer data, supervision of services provided to customers, invoicingfor services, and considering needs for services of different types.

The business management layer is used to monitor and plan the businessactivities and economy of the entire enterprise, resulting in decisionsaffecting the lower levels.

At present, network management systems are changing into systems thatmanage the telecommunications network as a whole, whereas conventionalmanagement systems have handled only the remote control of transmissionequipment, especially monitoring alarms produced by the equipment. Inconventional network management methods, configuration changes, such ascreation of new end-to-end connections, have been laborious andtime-consuming, as the end result consists of several configurationevents the prerequisite of which is that the maintenance staff of thenetwork first gets an overall view of the situation and then decides onconfiguration changes required in individual network elements. In newnetwork management systems, on the contrary, an overall view of thenetwork and its condition is produced within the system, and the systemitself gives the required configuration commands to each transmissionequipment. As a consequence, all configuration changes can be performedsignificantly more rapidly than previously. Such developments have beenaccelerated by the freeing of competition in the field oftelecommunications.

The above-mentioned recommendation M.3010 specifies the managementarchitecture as shown in FIG. 1. The architecture basically consists ofone or more operations systems OS connected to a data communicationnetwork DCN communicating with an actual telecommunications networkwhich is to be managed and which includes the network elements NEmanaged. It is to be noted that the connections of the datacommunications network and those of the telecommunications network arelogically distinct, although they can be implemented physically in oneand the same cable. Logically, there are thus two networks: (a) anetwork providing services to customers, and (b) a network maintainingthe service provisioning network. The management of certain transmissionequipments (network elements) further requires a separate MediationDevice MD, which mainly acts as a protocol converter between a Q3interface complying with the recommendations and transmission equipmentsthat do not understand the protocol applied in the interface but usetheir own proprietary protocol. New SDH equipment, for instance, can beconnected directly to the Q3 interface, whereas older PDH equipmentrequires a Mediation Device.

In practice, a management network for a combined SDH and PDH network maybe e.g. such as shown in FIG. 2. Users (network operator staff) sittingat the operation centre use network management work stations WSconnected to a separate local area network WSN, which may be e.g. anEthernet network. The management system is typically distributed inseveral computers of the local area network, one of the computers beinga dedicated application server SRV having a database DB containinginformation necessary for managing the network. In its practicalembodiment, the local area network further comprises e.g. necessaryback-up devices (like DAT drives or mirrored disks) and event-loggingprinters (not shown).

The management system is connected via the above-mentioned Q3 interfacee.g. to the SDH network. A variety of alternatives have been defined forthe Q3 interface, so that the interface may be e.g. an X.25 type packetswitched interface or an Ethernet LAN interface. (The packet switchedinterface is useful if the operator in charge of the network managementalso otherwise uses a packet switched network.) In practice, controlchannels between the SDH network elements 21 are established in theoverhead bytes of the STM-N signal (N=1, 4, 16), so that control signalsbetween SDH equipments propagate with the payload signal (that is, alsoin the same physical network). Such control channels established in theoverhead bytes are called Embedded Control Channels, and they are formede.g. in the STM-1 frame by the section overhead bytes D1 to D12.

PDH equipments, on the contrary, need manufacturer-specific solutions,wherefore they have to be connected to the management system through aseparate mediation device 22.

The management system may also be hierarchical so that differentgeographical areas have their own smaller management systems thattogether form an integral management network. For instance, a managementsystem covering one country may be divided geographically into smallermanagement systems operating in different parts of the country. Eachsmaller management system takes care of the management of the networkportion in the concerned geographical area. In the example of FIG. 2,management systems MS1 and MS2 geographically apart from each other formtogether a single common management system and management network.

Network management standards are nowadays largely based on so-calledobject-oriented descriptions, though the standards do not require theuse of this technique. Objects are data structures in a networkmanagement system, which describe the functions and state of a networkcomponent. An object is thus an element having certain attributes (“I amlike this”) and certain operations (“I can do these things”). (In theobject-oriented approach, objects with the same data structure(attributes) and the same behaviour (operations) are grouped into aclass. A specific implementation of an operation is called a method andeach object is said to be an instance of its class.) A typical object ise.g. a cross-connection device with certain attributes(cross-connections that are active) and certain methods (e.g. makecross-connection and release cross-connection).

In a telecommunications network management system, objects can bephysical ones or logical ones. Physical objects are elements that formpart of the physical network. Such objects are e.g. the above-mentionednetwork elements (a network element is any piece of telecommunicationequipment that works as a single unit to provide telecommunicationfunctions) or physical connections (such as optical fibres, twisted paircables, coaxial cables, radio links or satellite links). Logical objectsare logical entities that do not form a single piece of the physicalnetwork. Such objects are e.g. paths and circuits. (A path is aconnection of a fixed bit rate and format between two physicalinterfaces within the network. A circuit is a connection set up for acustomer, between two physical interfaces on the boundary of thenetwork. Thus, a circuit usually comprises several consecutive paths.)

A network object may have a number of different attributes. Someattributes (such as “fault state”) are used by several different typesof object. In addition, for some types of network object (such as aroute), it is convenient to define an attribute which consists of acollection of other attributes. Typical attributes are e.g.“availability status”, “fault state” and “operational state”. Theattributes have different possible values, e.g. fault state can havevalues:

OK. There are no problems.

Warning. There are outstanding faults, but these do not effect services.

Degraded. Some or all of the services provided by the object aredegraded.

Failed. All the services provided by the object are lost.

Unknown. The fault state of the object is unknown.

The “operational state”, in turn, can have e.g. two different values:

Enabled. The object can operate, either completely or in part.

Disabled. The object cannot operate at all.

The architecture of a network management system may also be presented ina simplified form as shown in FIG. 3. Users (people managing thetelecommunications network) sitting at an operation centre andmonitoring the situation of the network on the display of a work stationstart and terminate applications 30 to manage the network. (Theapplications are thus very transient elements). Applications are part ofthe system containing the user interface functionality. The applicationsoffer users the above-described services, such as end-to-end connectionmanagement, network optimisation and fault management. The applicationsconverse with the management system core 31, which is a backgroundprocess e.g. keeping record of events and maintaining a managementdatabase 32, i.e. a view of the network. In addition, the core gives theapplications 30 information about the managed objects when theapplications request such information. Correspondingly, the applicationscan change the attributes of an object in the database 32, in which casethe function of the core is to inform the concerned network element 33(which may also be the Mediation Device) of the change. The networkelement comprises its own (limited) database 34, which contains objectsrelated to this specific element.

In principle, the database 32 contains the data of all of the physicalelements of the network. It also contains a number of logical entities,such as objects describing customers and (end-to-end) customersconnections. The data are interrelated so that an inquiry can be madee.g. about the connections of a specific customer or the customer on aspecific connection. (It is to be noted that the physical networkcomprises no element describing the entire customer connection, but thenetwork comprises a plurality of separate elements each describing asmall portion of a connection.)

While an application is using objects, they must be held in theapplication's memory. When an application wishes to change theseobjects, they must first be locked to prevent other applications fromchanging them at the same time.

Due to the complex dependencies between objects, holding one object inmemory may require another to be held as well. Similarly, locking oneobject may require others to be locked. To give an example, when anapplication locks a path object so as to change its route, it must alsolock the objects that represent the network elements that will change asa result.

The complete model used to represent the network is almost always verylarge. The network can have tens of thousands of pieces of equipment andeach of these can have a number of objects associated with it, wherebythere can be even fifty to a hundred thousand objects representing anetwork. In practice, this is too much information to be kept in centralmemory at the same time. Therefore, the same technique can be appliedboth to throwing objects away from the memory when no longer required(so as to minimize memory use) and unlocking them. Consequently, what issaid about lock management in the following also applies to memorymanagement.

The dependencies between the objects are, in general, hidden from theapplication (and user) so that the application just locks the path andthe network elements are locked automatically. Similarly, when theapplication has completed its operation it frees the object from memoryand/or unlocks it, and all the other objects on which it depends arefreed and/or unlocked.

The problem behind the present invention is that of this unlockingand/or freeing, i.e. the problem how to check the dependencies betweenthe objects to be able to perform this unlocking and/or freeing in acorrect way. The solution to this problem is non-trivial, because thedependencies between objects can be cyclic, i.e. object A depends onobject B which depends on object C which depends on object A. (It is tobe noted that the problem of dependency checking is related only tounlocking, not to locking, because when an object must be locked, it isclear that all the objects that this object references must be locked.However, when the object is unlocked, other operations going on at thesame time may require the same object to be kept still locked, althoughthe operation that originally caused the locking does not any morerequire this.)

In the prior art there are a number solutions to this problem ofdependency checking. The solutions fall into two broad categories: (a)reference counting and (b) garbage collection. These two categories areillustrated in the following.

In the reference counting method, a count is associated to each object.Each time an object is referenced by another object, the countassociated with that object is raised. Each time the reference isremoved the count is reduced. When the count reaches zero, the objectcan be freed and/or unlocked. Also, any references from that object toothers can be removed as well, possibly causing further freeing and/orunlocking to take place.

FIGS. 4a . . . 4 e demonstrate how the reference counting method works.In the figures, two different objects, A and B, have been shown, eachbeing marked by a box labelled by the corresponding letter (A or B).Associated to each object box is the count box, labelled by the value ofthe corresponding counter. Initially (FIG. 4a), objects A and B have noreferences to them, whereby the associated counter values are zero. Then(FIG. 4b), something from outside references A (as shown by an arrow),whereby its reference count is incremented to one. (In practice, areference from an object to another, indicating a dependency betweenthose objects, can be implemented in any possible ways, e.g. by means ofa pointer word, i.e a binary number the value of which corresponds tothe object it is pointing to.)

After that (FIG. 4c), object A references object B, so the referencecount of object B is incremented. If the external reference to object Ais then removed, the count of object A is reduced to zero (FIG. 4d).When this happens, all references from object A to other objects arealso removed (FIG. 4e). Thus, in the example, the reference count ofobject B is also reduced to zero.

This kind of a solution is insufficient in a network management system,as it cannot cope with circular dependencies. Objects which are mutuallydependent end up keeping the count at a value greater than zero becausethey refer to each other even though nothing else refers to them. Thisis illustrated in figures 5 a . . . 5 d.

The initial situation (FIG. 5a) is such that object A references objectB and something from outside references object A. Then (FIG. 5b), objectB creates a reference back to object A; this increments the referencecount of object A to two. If the external reference is now removed, thereference count of object A is still one because object B is stillreferencing it (FIG. 5c). This leads to the situation of FIG. 5d, whereneither object A nor object B can be freed or unlocked because each hasa reference count of one, but the only things actually referencing theobjects are the objects themselves, i.e. the objects could actually beunlocked but the incorrect value of the reference count prevents it.

The second common form of dependency checking, called garbagecollection, is based on a different approach. In garbage collection, allthe links from a known root object or objects are periodically followedto all other objects, and each object that is reachable is marked asbeing still in use. Then all other objects that are no longer reachableare freed and/or unlocked.

What is used as the root object or objects varies from system to systemdepending on how the objects are designed to be linked together. Forexample, if garbage collection were used for the network managementsystem, the root objects would be those objects that had beenspecifically fetched and/or locked by the application using them; anyobjects that could no longer be reached from those objects could befreed and/or unlocked.

The example of FIGS. 6a to 6 d shows how garbage collection works. FIG.6a shows a group of objects A . . . F with links between them, includinga loop dependency between two objects, D and E. FIG. 6b shows two linksbeing removed, with the result that objects D and E are no longerreferenced by any other objects. Some what later (FIG. 6c), all thelinks reachable from the known root object (A in the example) arefollowed and all the reachable objects are marked. Reachable links andobjects are shown in solid lines in FIG. 6c, the others in dotted lines.After all reachable objects have been found, those that are no longerreachable are freed or unlocked. The result is shown in FIG. 6d.

This approach deals with the problem of circular references (asdemonstrated by the removal of D and E in the example), but isunsuitable for network management systems for the following reason.

Garbage collection does not find the unused objects as soon as they areunused. It is unacceptable for a (rapidly operating) network managementsystem to have a delay between when an object is no longer used and whenit is unlocked, as there may be many other applications waiting to usethe object.

The purpose of the present invention is to provide a novel solution forthe locking management in a telecommunications network managementsystem, not showing the above-mentioned drawbacks. This is achieved bymeans of the method according to the invention, which is characterizedby what is set forth in the characterizing portion of the attached claim1. The system according to the present invention is, for its part,characterized by what is set forth in the characterizing portion of theattached claim 6.

The dependencies between objects in the network management system can beregarded as a data structure known as a Directed Graph (DG). Thisrepresents the objects as nodes in the graph with directional linksbetween the nodes as the dependencies. Following the links from a nodecan lead back to that node; it is this feature that leads to e.g.reference counting in its basic form being inapplicable to lockmanagement, as mentioned earlier.

A related data structure is the Directed Acyclic Graph (DAG); this isidentical to the Directed Graph, except that it has the property that nonode can link back to itself either directly or indirectly. The idea ofthe invention is to add to the system an additional data structure sothat the dependencies between the objects can be viewed in a DAG form,to maintain this structure as a DAG after any changes in dependenciesbetween the objects, and to use simple reference counting in connectionwith this additional data structure to decide when objects can beunlocked and/or freed. A technique for converting DGs to DAGs alreadyexists (see Aho, Hopcroft & Ullman: Data Structures and Algorithms, pp222-226, Addison-Wesley, 1985, ISBN 0-21-00023-7). This technique worksby identifying all nodes in the old DG that form a circular dependencyand combining them to form a single node in a new DAG.

In the present invention this technique is applied to the problem ofdependency management in a telecommunications network management system,with the inclusion of various optimisations to minimise the overheadinvolved in maintaining the data structure. Thus, the idea of thepresent invention is to maintain in the system an auxiliary datastructure that does not include cyclic dependencies between the objects,and to utilize reference counting in connection with this datastructure. The system according to the present invention can be viewedas having two overlapping data structures: a first data structureincluding the objects and the references between them, and a second(auxiliary) data structure including the groups (of mutually dependentobjects) and the references between them.

The advantage of the present invention over existing reference countingapproaches is that arbitrary circular dependencies can be coped with.The advantage of the present invention over the known garbage collectionmethod is that by means of the present invention an object becomesunlocked as soon as it is no longer required to be locked. The presentinvention also has the benefit of spreading the computational load overeach lock/unlock operation rather than having it all occur at once.

Below, the invention and its preferred embodiments will be described ingreater detail with reference to the examples of FIGS. 7a . . . 7 h ofthe attached drawings, in which

FIG. 1 illustrates a telecommunications network management architecture,

FIG. 2 shows an example of a management network for a combined SDH andPDH network,

FIG. 3 illustrates the architecture of a network management system in asimplified form,

FIGS. 4a . . . 4 e demonstrate the function of one prior art method forlock management,

FIGS. 5a . . . 5 d demonstrate the function of the prior art method in asystem having mutually dependent objects,

FIGS. 6a . . . 6 d demonstrate the function of another prior art methodfor lock management,

FIGS. 7a . . . 7 h demonstrate the function of the method according tothe present invention.

The following description deals only with how lock management is carriedout using this technique, however, as mentioned above, the sametechnique can also be used to handle memory management.

According to the present invention, each lockable object has anothersimple lock group object associated with it. This lock group object actsas a sort of tag indicating which node within the DAG the lockableobject belongs to. Further, it is this lock group object that maintainsthe count of how many times the object(s) within the group has (have)been locked. When the count returns to zero, the object(s) is (are)unlocked.

When one lockable object locks another, if this additional referencecauses a circular path to be formed then all the lock groups of all theobjects in the circular path are combined into one new group. This newgroup is then used as the single lock group object for all of thoselockable objects. Thus, the lock group objects behave as nodes in a DAGbecause there can never be circular references between them, and sosimple reference counting using these objects is feasible.

The procedure followed when a new target object (belonging to the targetlock group) is locked by a source object (belonging to the source lockgroup, which is different from the target lock group) is as follows (inthe description an object referencing to another is called a parentwhereas the object referenced to is called a child):

1. Starting with the object just locked (the target), mark the objectand check each child object that the target object has locked (seebelow) to try to find the lock group of the source object. If it can befound, there is a dependency loop.

2. Each child is checked as follows:

2a. If the child belongs to the source lock group, increment the countof internal links and note that the source group (and thus a loop) hasbeen found.

2b. If the child is already marked, note that the source group has notbeen found.

2c. Else mark the child and check each of its locked children (i.e.repeat step 2 for the child's children).

2d. If any checked child (recursively) belongs to the source group, aloop has been found: if this child is not in the same group as theparent checking it, merge its lock group with the source lock group andincrement the count of internal links.

3. If a loop was found, merge the target group with the source group,but remove the count of internal links found from the total count ofreferences to the source group (so that only external references to thegroup are counted).

In the following the above-described principle is illustrated by anexample showing what happens when a new link is created that causes acircular reference to appear.

FIG. 7a shows five objects (numbered 1 to 5) and the reference groupsthey belong to (indicated by the dotted ovals and labelled A to D). Thethin arrows indicate internal references and the thick arrows referencesfrom outside. The dotted arrow is the new link that is just beingcreated.

At the initial stage of FIG. 7a the various counter values to be kepttrack of are (as can be seen from the figure):

References to group A: 1

References to group B: 3

References to group C: 2

References to group D: 1

Count of internal links L=0.

In the following, the numbering corresponds to the numbering of themethod steps described above.

1. Start at target object (object 1), mark it and check children.Marking has been illustrated in FIG. 7b by a shaded oval.

2. Check child of 1 (object 2).

2a. Object 2 is not part of the source group (C), so do not proceed (donot increment the count of internal links).

2b. Object 2 is not marked, so this item does not apply.

2c. Mark object 2 and check its children.

2. (FIG. 7c) Check child of object 2 (object 4).

2a. Object 4 is part of the source group (C), so increment the count ofinternal links.

Count of internal links: L=1

2. (FIG. 7d) Check child of object 2 (object 3).

2a. object 3 is not part of the source group (C), so do not proceed.

2b. Object 3 is not marked, so this item does not apply.

2c. Mark object 3 and check children.

2. (FIG. 7e) Check child of object 3 (object 2).

2a. Object 2 is not part of the source group (C), so do not proceed.

2b. Object 2 is already marked, so it is not in the source group (C).

2. Check child of object 3 (object 4).

2a. Object 4 is part of the source group (C), so increment count ofinternal links.

Count of internal links: L=2

2d. We have now checked all children of object 3 and found out that wecan access the source group (C), but this child (object 3) was checkedfrom a parent (object 2) in the same group (B), so do nothing more.

Return to parent of object 3, object 2.

Back at parent of object 3, object 2 (see FIG. 7f).

2d. We have now checked all children of object 2 and found out that wecan access the source group (C). As this child (object 2) was checkedfrom a parent (object 1) in a different group (A), the group (B) of thischild is merged with the source group (C) and the internal link count isincremented.

References to the new group C (see FIG. 7g) are now 5 (=B+C=3+2).

Internal link count: L=3

Return to parent of object 2, object 1.

Back at parent of object 2, object 1.

2. Check child of object 1 (object 3).

2a. Object 3 is part of the source group (C), so the count of internallinks is incremented.

Count of internal links: L=4

All the children of object 1 have now been checked, and (in this case)both of them were linked to the source group (C), so we can move to step3:

3. Merge the target group (A) into the source group (C), but remove thecount of internal links.

References to C: 2 (=A+C−L=1+5−4).

The end result is shown in FIG. 7h: Objects 1, 2, 3 and 4 are now all inthe same group (C) and the reference count to that group is 2.

As a result, objects 1 to 4 are now all in the same group (C) and thereference count for that group is the correct count of the number ofreferences to it from outside the group. After this, simple referencecounting can be used to decide when objects of a certain group can beunlocked. That is, when the reference count reaches a predeterminedvalue (showing that the number of references to that group is zero), thereferences from that group are removed. Depending on the chain ofreferences, this can cause further unlocking to take place.

In the above-described manner the smallest new group that no longer hasa cycle in it (like group C of FIG. 7h) and reference count to that newgroup are always worked out when maintaining the data structure afterthe objects and/or the references between the objects change.

In the above example, the children of each object were followed fromleft to right and then top to bottom, but the method works correctlywhatever the ordering.

The above described recursive checking each time one object is locked byanother could be computationally expensive, given that there arepotentially thousands of links between the network management systemobjects. This cost is reduced by the following preferred embodiments ofthe present invention.

According to the first preferred embodiment the locking of a previouslyunlocked object requires no further checking (there can be no loopbecause the object cannot have caused another object to be locked if ititself is unlocked). Hence the recursive descent checking only takesplace if the same object is locked from two or more different sources.

The procedure above marks objects to indicate that they have beenchecked. According to the second preferred embodiment this marking isdone by setting e.g. a field in the object to a unique value associatedwith the source lock group being checked for.

Normally the use of marking would require a second pass over the objectsto remove any marks set so that the next time the check is performed theobjects can be marked again. This is made unnecessary by the use of thegroup's unique value because:

if a different group is being checked for, the object will appear to beunmarked, and

if the same group is being checked for, the existance of the markindicates that all children below that object have already been checkedfor membership of that group and so do not need to be checked again.

Thus, the use of this marking technique avoids computation by removingthe need for a mark-clearing pass, and by removing the need to recheckall the objects below a given object if that object has already beenmarked for the group being searched for.

Though the invention has been described above referring to the exampleof the attached drawing, it is obvious that the invention is notrestricted to that, but it can be modified in many ways within the scopeof the inventive idea presented above and in the attached claims. Asmentioned above, the management system includes a variety of objects,representing both logical and physical entities. In the enclosed claimsall these objects are are set forth as “the objects that relate to thenetwork elements to be managed”, i.e. objects that represent the managedenvironment.

What is claimed is:
 1. A method for managing a telecommunicationsnetwork, said telecommunications network comprising several networkelements to be managed by the system, said system comprising amanagement centre having at least one workstation accomplishing aman-machine interface and allowing a manager to control the system, andthe system being capable of providing the manager with information onthe network, said at least one workstation being connected to a databaseincluding information about the managed network, said information beingin the form of objects that relate to the network elements to be managedand in the form of references between the different objects, saidreferences indicating the dependencies between the objects, whereby saidmanagement centre is connected to said network elements by datacommunication links such that the manager can initiate an operation on amanaged item of the network, in which method when the informationcontent of an object is changed by an operation, (a) said object and allthe objects depending on it are first locked to prevent anotheroperation from changing the information content of said objects at thesame time, (b) after said change has been completed a dependencychecking is performed to find all dependent objects that can beunlocked, characterized in that an additional (auxiliary) data structureis formed from lockable objects, said data structure comprising objectgroups formed in such a way that the relationships between the objectswithin a single group can be cyclic and the relationships between thegroups are all acyclic, each group having a count associated with it,said count corresponding to the number of references made to the groupfrom outside, when a source object has created a new reference to atarget object, the number of groups and said count are updated so thatthe relationships between the groups are still all acyclic, and objectswithin a group are unlocked when said count has a predetermined value.2. A method according to claim 1, characterized in that when performingsaid updating, the dependencies between the objects are followed,starting from the target object and checking the groups of the childobjects that the target object has locked, while at the same timekeeping track of a count of internal links corresponding to the linksfound between the different groups, and if a child object belonging tothe source group is found, the source group is merged with the group ofthe parent object, provided that the group of the parent object is notthe same as the source group.
 3. A method according to claim 1,characterized in that when the source group is merged with the targetgroup, the total count of internal links found is subtracted from thetotal count of references to the merged source group.
 4. A methodaccording to claim 1, characterized in that said updating is performedonly if the target object is already locked when the source object hascreated a new reference to the target object.
 5. A method according toclaim 2, characterized in that an object is marked to indicate that itslocked child objects have been checked, said marking being done bygiving the mark a value which is unique, to the source group inquestion.
 6. A network management system for a telecommunicationsnetwork, said telecommunications network comprising several networkelements to be managed by the system, said system comprising amanagement centre having at least one workstation accomplishing aman-machine interface and allowing a manager to control the system, andthe system being capable of providing the manager with information onthe network, said at least one workstation being connected to a databaseincluding information about the managed network, said information beingin the form of objects that relate to the network elements to be managedand in the form of references between the different objects, saidreferences indicating the dependencies between the objects, whereby saidmanagement centre is connected to said network elements by datacommunication links such that the manager can initiate an operation onand receive information from a managed item of the network,characterized in that the system comprises an additional (auxiliary)data structure comprising object groups formed in such a way that therelationships between the objects within a single group can be cyclicand the relationships between the groups are all acyclic, each grouphaving a count associated with it, said count corresponding to thenumber of references made to the group from outside.